{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 机器学习练习-决策树\n",
    "\n",
    "实验要求：1，请将本实验中两处代码不完整的地方补充完整：2，如果出现graphviz问题，请尝试解决；3，对照本章ppt和本实验代码，理解决策树原理。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1．分类决策树模型是表示基于特征对实例进行分类的树形结构。决策树可以转换成一个**if-then**规则的集合，也可以看作是定义在特征空间划分上的类的条件概率分布。\n",
    "\n",
    "2．决策树学习旨在构建一个与训练数据拟合很好，并且复杂度小的决策树。因为从可能的决策树中直接选取最优决策树是NP完全问题。现实中采用启发式方法学习次优的决策树。\n",
    "\n",
    "决策树学习算法包括3部分：特征选择、树的生成和树的剪枝。常用的算法有ID3、\n",
    "C4.5和CART。\n",
    "\n",
    "3．特征选择的目的在于选取对训练数据能够分类的特征。特征选择的关键是其准则。常用的准则如下：\n",
    "\n",
    "（1）样本集合$D$对特征$A$的信息增益（ID3）\n",
    "\n",
    "\n",
    "$$g(D, A)=H(D)-H(D|A)$$\n",
    "\n",
    "$$H(D)=-\\sum_{k=1}^{K} \\frac{\\left|C_{k}\\right|}{|D|} \\log _{2} \\frac{\\left|C_{k}\\right|}{|D|}$$\n",
    "\n",
    "$$H(D | A)=\\sum_{i=1}^{n} \\frac{\\left|D_{i}\\right|}{|D|} H\\left(D_{i}\\right)$$\n",
    "\n",
    "其中，$H(D)$是数据集$D$的熵，$H(D_i)$是数据集$D_i$的熵，$H(D|A)$是数据集$D$对特征$A$的条件熵。\t$D_i$是$D$中特征$A$取第$i$个值的样本子集，$C_k$是$D$中属于第$k$类的样本子集。$n$是特征$A$取 值的个数，$K$是类的个数。\n",
    "\n",
    "（2）样本集合$D$对特征$A$的信息增益比（C4.5）\n",
    "\n",
    "\n",
    "$$g_{R}(D, A)=\\frac{g(D, A)}{H(D)}$$\n",
    "\n",
    "\n",
    "其中，$g(D,A)$是信息增益，$H(D)$是数据集$D$的熵。\n",
    "\n",
    "（3）样本集合$D$的基尼指数（CART）\n",
    "\n",
    "$$\\operatorname{Gini}(D)=1-\\sum_{k=1}^{K}\\left(\\frac{\\left|C_{k}\\right|}{|D|}\\right)^{2}$$\n",
    "\n",
    "特征$A$条件下集合$D$的基尼指数：\n",
    "\n",
    " $$\\operatorname{Gini}(D, A)=\\frac{\\left|D_{1}\\right|}{|D|} \\operatorname{Gini}\\left(D_{1}\\right)+\\frac{\\left|D_{2}\\right|}{|D|} \\operatorname{Gini}\\left(D_{2}\\right)$$\n",
    " \n",
    "4．决策树的生成。通常使用信息增益最大、信息增益比最大或基尼指数最小作为特征选择的准则。决策树的生成往往通过计算信息增益或其他指标，从根结点开始，递归地产生决策树。这相当于用信息增益或其他准则不断地选取局部最优的特征，或将训练集分割为能够基本正确分类的子集。\n",
    "\n",
    "5．决策树的剪枝。由于生成的决策树存在过拟合问题，需要对它进行剪枝，以简化学到的决策树。决策树的剪枝，往往从已生成的树上剪掉一些叶结点或叶结点以上的子树，并将其父结点或根结点作为新的叶结点，从而简化生成的决策树。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import pandas as pd\n",
    "import math\n",
    "from math import log\n",
    "import os\n",
    "graphviz_path = r\"C:\\Program Files\\Graphviz\"\n",
    "os.environ[\"PATH\"] += os.pathsep + graphviz_path"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 创建数据"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_data():\n",
    "    datasets = [['青年', '否', '否', '一般', '否'],\n",
    "               ['青年', '否', '否', '好', '否'],\n",
    "               ['青年', '是', '否', '好', '是'],\n",
    "               ['青年', '是', '是', '一般', '是'],\n",
    "               ['青年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '一般', '否'],\n",
    "               ['中年', '否', '否', '好', '否'],\n",
    "               ['中年', '是', '是', '好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['中年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '非常好', '是'],\n",
    "               ['老年', '否', '是', '好', '是'],\n",
    "               ['老年', '是', '否', '好', '是'],\n",
    "               ['老年', '是', '否', '非常好', '是'],\n",
    "               ['老年', '否', '否', '一般', '否'],\n",
    "               ]\n",
    "    labels = [u'年龄', u'有工作', u'有自己的房子', u'信贷情况', u'类别']\n",
    "    # 返回数据集和每个维度的名称\n",
    "    return datasets, labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_data = pd.DataFrame(datasets, columns=labels) #请将本行代码补充完整"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>年龄</th>\n",
       "      <th>有工作</th>\n",
       "      <th>有自己的房子</th>\n",
       "      <th>信贷情况</th>\n",
       "      <th>类别</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>青年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>一般</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>青年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>中年</td>\n",
       "      <td>是</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>中年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>10</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>11</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>是</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>12</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>13</th>\n",
       "      <td>老年</td>\n",
       "      <td>是</td>\n",
       "      <td>否</td>\n",
       "      <td>非常好</td>\n",
       "      <td>是</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>14</th>\n",
       "      <td>老年</td>\n",
       "      <td>否</td>\n",
       "      <td>否</td>\n",
       "      <td>一般</td>\n",
       "      <td>否</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "    年龄 有工作 有自己的房子 信贷情况 类别\n",
       "0   青年   否      否   一般  否\n",
       "1   青年   否      否    好  否\n",
       "2   青年   是      否    好  是\n",
       "3   青年   是      是   一般  是\n",
       "4   青年   否      否   一般  否\n",
       "5   中年   否      否   一般  否\n",
       "6   中年   否      否    好  否\n",
       "7   中年   是      是    好  是\n",
       "8   中年   否      是  非常好  是\n",
       "9   中年   否      是  非常好  是\n",
       "10  老年   否      是  非常好  是\n",
       "11  老年   否      是    好  是\n",
       "12  老年   是      否    好  是\n",
       "13  老年   是      否  非常好  是\n",
       "14  老年   否      否   一般  否"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集的熵（信息熵）\n",
    "def calc_ent(datasets):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 统计数据集中每个类别的出现次数\n",
    "    label_count = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本的标签\n",
    "        label = datasets[i][-1]\n",
    "        # 如果该类别不在label_count中，则添加到label_count中\n",
    "        if label not in label_count:\n",
    "            label_count[label] = 0\n",
    "        # 统计该类别的出现次数\n",
    "        label_count[label] += 1\n",
    "    # 计算熵\n",
    "    ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                for p in label_count.values()])\n",
    "    return ent"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 条件熵"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算给定数据集在指定特征上的条件熵\n",
    "def cond_ent(datasets, axis=0):\n",
    "    # 计算数据集的长度\n",
    "    data_length = len(datasets)\n",
    "    # 使用字典feature_sets存储在指定特征上的不同取值对应的样本集合\n",
    "    feature_sets = {}\n",
    "    for i in range(data_length):\n",
    "        # 获取每个样本在指定特征上的取值\n",
    "        feature = datasets[i][axis]\n",
    "        # 如果该取值不在feature_sets中，则添加到feature_sets中\n",
    "        if feature not in feature_sets:\n",
    "            feature_sets[feature] = []\n",
    "        # 将该样本添加到对应取值的样本集合中\n",
    "        feature_sets[feature].append(datasets[i])\n",
    "    # 计算条件熵\n",
    "    cond_ent = sum([(len(p) / data_length) * calc_ent(p)\n",
    "                    for p in feature_sets.values()])\n",
    "    return cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9709505944546686"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "calc_ent(datasets)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 信息增益"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 计算信息增益\n",
    "def info_gain(ent, cond_ent):\n",
    "    # 信息增益等于熵减去条件熵\n",
    "    return ent - cond_ent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 使用信息增益选择最佳特征作为根节点特征进行决策树的训练\n",
    "def info_gain_train(datasets):\n",
    "    # 计算特征的数量\n",
    "    count = len(datasets[0]) - 1\n",
    "    # 计算整个数据集的熵\n",
    "    ent = calc_ent(datasets)\n",
    "    # 存储每个特征的信息增益\n",
    "    best_feature = []\n",
    "    for c in range(count):\n",
    "        # 计算每个特征的条件熵\n",
    "        c_info_gain = info_gain(ent, cond_ent(datasets, axis=c))\n",
    "        # 将特征及其对应的信息增益存入best_feature列表中\n",
    "        best_feature.append((c, c_info_gain))\n",
    "        # 输出每个特征的信息增益\n",
    "        print('特征({}) 的信息增益为： {:.3f}'.format(labels[c], c_info_gain))\n",
    "    # 找到信息增益最大的特征\n",
    "    best_ = max(best_feature, key=lambda x: x[-1])\n",
    "    # 返回信息增益最大的特征作为根节点特征\n",
    "    return '特征({})的信息增益最大，选择为根节点特征'.format(labels[best_[0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "特征(年龄) 的信息增益为： 0.083\n",
      "特征(有工作) 的信息增益为： 0.324\n",
      "特征(有自己的房子) 的信息增益为： 0.420\n",
      "特征(信贷情况) 的信息增益为： 0.363\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "'特征(有自己的房子)的信息增益最大，选择为根节点特征'"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "info_gain_train(np.array(datasets))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "### 利用ID3算法生成决策树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 定义节点类 二叉树\n",
    "class Node:\n",
    "    def __init__(self, root=True, label=None, feature_name=None, feature=None):\n",
    "        self.root = root\n",
    "        self.label = label\n",
    "        self.feature_name = feature_name\n",
    "        self.feature = feature\n",
    "        self.tree = {}\n",
    "        self.result = {\n",
    "            'label:': self.label,\n",
    "            'feature': self.feature,\n",
    "            'tree': self.tree\n",
    "        }\n",
    "\n",
    "    def __repr__(self):\n",
    "        return '{}'.format(self.result)\n",
    "\n",
    "    def add_node(self, val, node):\n",
    "        self.tree[val] = node\n",
    "\n",
    "    def predict(self, features):\n",
    "        if self.root is True:\n",
    "            return self.label\n",
    "        return self.tree[features[self.feature]].predict(features)\n",
    "\n",
    "\n",
    "class DTree:\n",
    "    def __init__(self, epsilon=0.1):\n",
    "        self.epsilon = epsilon\n",
    "        self._tree = {}\n",
    "\n",
    "    # 熵\n",
    "    @staticmethod\n",
    "    def calc_ent(datasets):\n",
    "        data_length = len(datasets)\n",
    "        label_count = {}\n",
    "        for i in range(data_length):\n",
    "            label = datasets[i][-1]\n",
    "            if label not in label_count:\n",
    "                label_count[label] = 0\n",
    "            label_count[label] += 1\n",
    "        ent = -sum([(p / data_length) * log(p / data_length, 2)\n",
    "                    for p in label_count.values()])\n",
    "        return ent\n",
    "\n",
    "    # 经验条件熵\n",
    "    def cond_ent(self, datasets, axis=0):\n",
    "        data_length = len(datasets)\n",
    "        feature_sets = {}\n",
    "        for i in range(data_length):\n",
    "            feature = datasets[i][axis]\n",
    "            if feature not in feature_sets:\n",
    "                feature_sets[feature] = []\n",
    "            feature_sets[feature].append(datasets[i])\n",
    "        cond_ent = sum([(len(p) / data_length) * self.calc_ent(p)\n",
    "                        for p in feature_sets.values()])\n",
    "        return cond_ent\n",
    "\n",
    "    # 信息增益\n",
    "    @staticmethod\n",
    "    def info_gain(ent, cond_ent):\n",
    "        return ent - cond_ent\n",
    "\n",
    "    def info_gain_train(self, datasets):\n",
    "        count = len(datasets[0]) - 1\n",
    "        ent = self.calc_ent(datasets)\n",
    "        best_feature = []\n",
    "        for c in range(count):\n",
    "            c_info_gain = self.info_gain(ent, self.cond_ent(datasets, axis=c))\n",
    "            best_feature.append((c, c_info_gain))\n",
    "        # 比较大小\n",
    "        best_ = max(best_feature, key=lambda x: x[-1])\n",
    "        return best_\n",
    "\n",
    "    def train(self, train_data):\n",
    "        \"\"\"\n",
    "        input:数据集D(DataFrame格式)，特征集A，阈值eta\n",
    "        output:决策树T\n",
    "        \"\"\"\n",
    "        _, y_train, features = train_data.iloc[:, :\n",
    "                                               -1], train_data.iloc[:,\n",
    "                                                                    -1], train_data.columns[:\n",
    "                                                                                            -1]\n",
    "        # 1,若D中实例属于同一类Ck，则T为单节点树，并将类Ck作为结点的类标记，返回T\n",
    "        if len(y_train.value_counts()) == 1:\n",
    "            return Node(root=True, label=y_train.iloc[0])\n",
    "\n",
    "        # 2, 若A为空，则T为单节点树，将D中实例树最大的类Ck作为该节点的类标记，返回T\n",
    "        if len(features) == 0:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 3,计算最大信息增益 同5.1,Ag为信息增益最大的特征\n",
    "        max_feature, max_info_gain = self.info_gain_train(np.array(train_data))\n",
    "        max_feature_name = features[max_feature]\n",
    "\n",
    "        # 4,Ag的信息增益小于阈值eta,则置T为单节点树，并将D中是实例数最大的类Ck作为该节点的类标记，返回T\n",
    "        if max_info_gain < self.epsilon:\n",
    "            return Node(\n",
    "                root=True,\n",
    "                label=y_train.value_counts().sort_values(\n",
    "                    ascending=False).index[0])\n",
    "\n",
    "        # 5,构建Ag子集\n",
    "        node_tree = Node(\n",
    "            root=False, feature_name=max_feature_name, feature=max_feature)\n",
    "\n",
    "        feature_list = train_data[max_feature_name].value_counts().index\n",
    "        for f in feature_list:\n",
    "            sub_train_df = train_data.loc[train_data[max_feature_name] ==\n",
    "                                          f].drop([max_feature_name], axis=1)\n",
    "\n",
    "            # 6, 递归生成树\n",
    "            sub_tree = self.train(sub_train_df)\n",
    "            node_tree.add_node(f, sub_tree)\n",
    "\n",
    "        # pprint.pprint(node_tree.tree)\n",
    "        return node_tree\n",
    "\n",
    "    def fit(self, train_data):\n",
    "        self._tree = self.train(train_data)\n",
    "        return self._tree\n",
    "\n",
    "    def predict(self, X_test):\n",
    "        return self._tree.predict(X_test)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [],
   "source": [
    "datasets, labels = create_data()\n",
    "data_df = pd.DataFrame(datasets, columns=labels)\n",
    "dt = DTree()\n",
    "tree = dt.fit(data_df)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'label:': None, 'feature': 2, 'tree': {'否': {'label:': None, 'feature': 1, 'tree': {'否': {'label:': '否', 'feature': None, 'tree': {}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}, '是': {'label:': '是', 'feature': None, 'tree': {}}}}"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tree"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'否'"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dt.predict(['老年', '否', '否', '一般'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn实例"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.datasets import load_iris\n",
    "from sklearn.model_selection import train_test_split\n",
    "from collections import Counter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "使用Iris数据集，我们可以构建如下树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "# data\n",
    "def create_data():\n",
    "    iris = load_iris() #请将本行代码补充完整       \n",
    "    df = pd.DataFrame(iris.data, columns=iris.feature_names)\n",
    "    df['label'] = iris.target\n",
    "    df.columns = [\n",
    "        'sepal length', 'sepal width', 'petal length', 'petal width', 'label'\n",
    "    ]\n",
    "    data = np.array(df.iloc[:100, [0, 1, -1]])\n",
    "    # print(data)\n",
    "    return data[:, :2], data[:, -1],iris.feature_names[0:2]\n",
    "\n",
    "\n",
    "X, y,feature_name= create_data()\n",
    "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树分类"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.9666666666666667"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn.tree import export_graphviz\n",
    "import graphviz\n",
    "from sklearn import tree\n",
    "\n",
    "clf = DecisionTreeClassifier()\n",
    "clf.fit(X_train, y_train,)\n",
    "\n",
    "clf.score(X_test, y_test)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "一旦经过训练，就可以用 plot_tree函数绘制树："
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Text(0.5, 0.9, 'x[0] <= 5.45\\ngini = 0.496\\nsamples = 70\\nvalue = [32, 38]'),\n",
       " Text(0.25, 0.7, 'x[1] <= 2.8\\ngini = 0.284\\nsamples = 35\\nvalue = [29, 6]'),\n",
       " Text(0.125, 0.5, 'gini = 0.0\\nsamples = 5\\nvalue = [0, 5]'),\n",
       " Text(0.375, 0.5, 'x[1] <= 3.05\\ngini = 0.064\\nsamples = 30\\nvalue = [29, 1]'),\n",
       " Text(0.25, 0.3, 'x[0] <= 5.2\\ngini = 0.375\\nsamples = 4\\nvalue = [3, 1]'),\n",
       " Text(0.125, 0.1, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]'),\n",
       " Text(0.375, 0.1, 'gini = 0.0\\nsamples = 1\\nvalue = [0, 1]'),\n",
       " Text(0.5, 0.3, 'gini = 0.0\\nsamples = 26\\nvalue = [26, 0]'),\n",
       " Text(0.75, 0.7, 'x[1] <= 3.45\\ngini = 0.157\\nsamples = 35\\nvalue = [3, 32]'),\n",
       " Text(0.625, 0.5, 'gini = 0.0\\nsamples = 32\\nvalue = [0, 32]'),\n",
       " Text(0.875, 0.5, 'gini = 0.0\\nsamples = 3\\nvalue = [3, 0]')]"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "tree.plot_tree(clf) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "也可以导出树"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [],
   "source": [
    "tree_pic = export_graphviz(clf, out_file=\"mytree.pdf\")\n",
    "with open('mytree.pdf') as f:\n",
    "    dot_graph = f.read()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": [
       "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n",
       "<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n",
       " \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n",
       "<!-- Generated by graphviz version 12.2.1 (20241206.2353)\n",
       " -->\n",
       "<!-- Title: Tree Pages: 1 -->\n",
       "<svg width=\"454pt\" height=\"491pt\"\n",
       " viewBox=\"0.00 0.00 454.00 491.25\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n",
       "<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 487.25)\">\n",
       "<title>Tree</title>\n",
       "<polygon fill=\"white\" stroke=\"none\" points=\"-4,4 -4,-487.25 450,-487.25 450,4 -4,4\"/>\n",
       "<!-- 0 -->\n",
       "<g id=\"node1\" class=\"node\">\n",
       "<title>0</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"277.5,-483.25 168.5,-483.25 168.5,-412.25 277.5,-412.25 277.5,-483.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-465.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.45</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-450.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.496</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-434.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 70</text>\n",
       "<text text-anchor=\"middle\" x=\"223\" y=\"-418.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [32, 38]</text>\n",
       "</g>\n",
       "<!-- 1 -->\n",
       "<g id=\"node2\" class=\"node\">\n",
       "<title>1</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-376.25 112.25,-376.25 112.25,-305.25 213.75,-305.25 213.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 2.8</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.284</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 35</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [29, 6]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;1 -->\n",
       "<g id=\"edge1\" class=\"edge\">\n",
       "<title>0&#45;&gt;1</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M203.02,-411.79C198.37,-403.64 193.35,-394.86 188.49,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"191.64,-384.82 183.64,-377.87 185.57,-388.29 191.64,-384.82\"/>\n",
       "<text text-anchor=\"middle\" x=\"176.31\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">True</text>\n",
       "</g>\n",
       "<!-- 8 -->\n",
       "<g id=\"node9\" class=\"node\">\n",
       "<title>8</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-376.25 232.25,-376.25 232.25,-305.25 333.75,-305.25 333.75,-376.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-358.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.45</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-343.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.157</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-327.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 35</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-311.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 32]</text>\n",
       "</g>\n",
       "<!-- 0&#45;&gt;8 -->\n",
       "<g id=\"edge8\" class=\"edge\">\n",
       "<title>0&#45;&gt;8</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M242.98,-411.79C247.63,-403.64 252.65,-394.86 257.51,-386.36\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"260.43,-388.29 262.36,-377.87 254.36,-384.82 260.43,-388.29\"/>\n",
       "<text text-anchor=\"middle\" x=\"269.69\" y=\"-395.25\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">False</text>\n",
       "</g>\n",
       "<!-- 2 -->\n",
       "<g id=\"node3\" class=\"node\">\n",
       "<title>2</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"94,-261.38 0,-261.38 0,-206.12 94,-206.12 94,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 5</text>\n",
       "<text text-anchor=\"middle\" x=\"47\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 5]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;2 -->\n",
       "<g id=\"edge2\" class=\"edge\">\n",
       "<title>1&#45;&gt;2</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M124.37,-304.79C111.74,-293.35 97.71,-280.65 85.11,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"87.54,-266.72 77.77,-262.61 82.84,-271.91 87.54,-266.72\"/>\n",
       "</g>\n",
       "<!-- 3 -->\n",
       "<g id=\"node4\" class=\"node\">\n",
       "<title>3</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"213.75,-269.25 112.25,-269.25 112.25,-198.25 213.75,-198.25 213.75,-269.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-251.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[1] &lt;= 3.05</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-236.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.064</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-220.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 30</text>\n",
       "<text text-anchor=\"middle\" x=\"163\" y=\"-204.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [29, 1]</text>\n",
       "</g>\n",
       "<!-- 1&#45;&gt;3 -->\n",
       "<g id=\"edge3\" class=\"edge\">\n",
       "<title>1&#45;&gt;3</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M163,-304.79C163,-297.17 163,-289 163,-281.02\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"166.5,-281.07 163,-271.07 159.5,-281.07 166.5,-281.07\"/>\n",
       "</g>\n",
       "<!-- 4 -->\n",
       "<g id=\"node5\" class=\"node\">\n",
       "<title>4</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"152,-162.25 58,-162.25 58,-91.25 152,-91.25 152,-162.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-144.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">x[0] &lt;= 5.2</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-129.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.375</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-113.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 4</text>\n",
       "<text text-anchor=\"middle\" x=\"105\" y=\"-97.7\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 1]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;4 -->\n",
       "<g id=\"edge4\" class=\"edge\">\n",
       "<title>3&#45;&gt;4</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M143.69,-197.79C139.24,-189.73 134.44,-181.05 129.79,-172.63\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"132.86,-170.95 124.96,-163.89 126.73,-174.33 132.86,-170.95\"/>\n",
       "</g>\n",
       "<!-- 7 -->\n",
       "<g id=\"node8\" class=\"node\">\n",
       "<title>7</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"271.75,-154.38 170.25,-154.38 170.25,-99.12 271.75,-99.12 271.75,-154.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-137.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-121.33\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 26</text>\n",
       "<text text-anchor=\"middle\" x=\"221\" y=\"-105.58\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [26, 0]</text>\n",
       "</g>\n",
       "<!-- 3&#45;&gt;7 -->\n",
       "<g id=\"edge7\" class=\"edge\">\n",
       "<title>3&#45;&gt;7</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M182.31,-197.79C188.21,-187.12 194.7,-175.36 200.66,-164.57\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"203.67,-166.36 205.44,-155.91 197.54,-162.98 203.67,-166.36\"/>\n",
       "</g>\n",
       "<!-- 5 -->\n",
       "<g id=\"node6\" class=\"node\">\n",
       "<title>5</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"96,-55.25 2,-55.25 2,0 96,0 96,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"49\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"49\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"49\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 0]</text>\n",
       "</g>\n",
       "<!-- 4&#45;&gt;5 -->\n",
       "<g id=\"edge5\" class=\"edge\">\n",
       "<title>4&#45;&gt;5</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M84.94,-90.96C80.17,-82.68 75.06,-73.81 70.23,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"73.31,-63.78 65.28,-56.87 67.25,-67.28 73.31,-63.78\"/>\n",
       "</g>\n",
       "<!-- 6 -->\n",
       "<g id=\"node7\" class=\"node\">\n",
       "<title>6</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"208,-55.25 114,-55.25 114,0 208,0 208,-55.25\"/>\n",
       "<text text-anchor=\"middle\" x=\"161\" y=\"-37.95\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"161\" y=\"-22.2\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 1</text>\n",
       "<text text-anchor=\"middle\" x=\"161\" y=\"-6.45\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 1]</text>\n",
       "</g>\n",
       "<!-- 4&#45;&gt;6 -->\n",
       "<g id=\"edge6\" class=\"edge\">\n",
       "<title>4&#45;&gt;6</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M125.06,-90.96C129.83,-82.68 134.94,-73.81 139.77,-65.45\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"142.75,-67.28 144.72,-56.87 136.69,-63.78 142.75,-67.28\"/>\n",
       "</g>\n",
       "<!-- 9 -->\n",
       "<g id=\"node10\" class=\"node\">\n",
       "<title>9</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"333.75,-261.38 232.25,-261.38 232.25,-206.12 333.75,-206.12 333.75,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 32</text>\n",
       "<text text-anchor=\"middle\" x=\"283\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [0, 32]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;9 -->\n",
       "<g id=\"edge9\" class=\"edge\">\n",
       "<title>8&#45;&gt;9</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M283,-304.79C283,-294.56 283,-283.32 283,-272.91\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"286.5,-273.1 283,-263.1 279.5,-273.1 286.5,-273.1\"/>\n",
       "</g>\n",
       "<!-- 10 -->\n",
       "<g id=\"node11\" class=\"node\">\n",
       "<title>10</title>\n",
       "<polygon fill=\"none\" stroke=\"black\" points=\"446,-261.38 352,-261.38 352,-206.12 446,-206.12 446,-261.38\"/>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-244.07\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">gini = 0.0</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-228.32\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">samples = 3</text>\n",
       "<text text-anchor=\"middle\" x=\"399\" y=\"-212.57\" font-family=\"Helvetica,sans-Serif\" font-size=\"14.00\">value = [3, 0]</text>\n",
       "</g>\n",
       "<!-- 8&#45;&gt;10 -->\n",
       "<g id=\"edge10\" class=\"edge\">\n",
       "<title>8&#45;&gt;10</title>\n",
       "<path fill=\"none\" stroke=\"black\" d=\"M321.63,-304.79C334.26,-293.35 348.29,-280.65 360.89,-269.25\"/>\n",
       "<polygon fill=\"black\" stroke=\"black\" points=\"363.16,-271.91 368.23,-262.61 358.46,-266.72 363.16,-271.91\"/>\n",
       "</g>\n",
       "</g>\n",
       "</svg>\n"
      ],
      "text/plain": [
       "<graphviz.sources.Source at 0x1902f3fd290>"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "graphviz.Source(dot_graph)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树回归"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create a random dataset\n",
    "rng = np.random.RandomState(1)\n",
    "X = np.sort(5 * rng.rand(80, 1), axis=0)\n",
    "y = np.sin(X).ravel()\n",
    "y[::5] += 3 * (0.5 - rng.rand(16))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Fit regression model\n",
    "regr_1 = DecisionTreeRegressor(max_depth=2)\n",
    "regr_2 = DecisionTreeRegressor(max_depth=5)\n",
    "regr_1.fit(X, y)\n",
    "regr_2.fit(X, y)\n",
    "\n",
    "# Predict\n",
    "X_test = np.arange(0.0, 5.0, 0.01)[:, np.newaxis]\n",
    "y_1 = regr_1.predict(X_test)\n",
    "y_2 = regr_2.predict(X_test)\n",
    "\n",
    "# Plot the results\n",
    "plt.figure()\n",
    "plt.scatter(X, y, s=20, edgecolor=\"black\", c=\"darkorange\", label=\"data\")\n",
    "plt.plot(X_test, y_1, color=\"cornflowerblue\", label=\"max_depth=2\", linewidth=2)\n",
    "plt.plot(X_test, y_2, color=\"yellowgreen\", label=\"max_depth=5\", linewidth=2)\n",
    "plt.xlabel(\"data\")\n",
    "plt.ylabel(\"target\")\n",
    "plt.title(\"Decision Tree Regression\")\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scikit-learn 的决策树参数"
   ]
  },
  {
   "cell_type": "raw",
   "metadata": {},
   "source": [
    "DecisionTreeClassifier(criterion=\"gini\",\n",
    "                 splitter=\"best\",\n",
    "                 max_depth=None,\n",
    "                 min_samples_split=2,\n",
    "                 min_samples_leaf=1,\n",
    "                 min_weight_fraction_leaf=0.,\n",
    "                 max_features=None,\n",
    "                 random_state=None,\n",
    "                 max_leaf_nodes=None,\n",
    "                 min_impurity_decrease=0.,\n",
    "                 min_impurity_split=None,\n",
    "                 class_weight=None,\n",
    "                 presort=False)\n",
    "\n",
    "参数含义：\n",
    "1.criterion:string, optional (default=\"gini\")\n",
    "            (1).criterion='gini',分裂节点时评价准则是Gini指数。\n",
    "            (2).criterion='entropy',分裂节点时的评价指标是信息增益。\n",
    "2.max_depth:int or None, optional (default=None)。指定树的最大深度。\n",
    "            如果为None，表示树的深度不限。直到所有的叶子节点都是纯净的，即叶子节点\n",
    "            中所有的样本点都属于同一个类别。或者每个叶子节点包含的样本数小于min_samples_split。\n",
    "3.splitter:string, optional (default=\"best\")。指定分裂节点时的策略。\n",
    "           (1).splitter='best',表示选择最优的分裂策略。\n",
    "           (2).splitter='random',表示选择最好的随机切分策略。\n",
    "4.min_samples_split:int, float, optional (default=2)。表示分裂一个内部节点需要的做少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每次分裂最少样本数为ceil(min_samples_split * n_samples)\n",
    "5.min_samples_leaf: int, float, optional (default=1)。指定每个叶子节点需要的最少样本数。\n",
    "           (1).如果为整数，则min_samples_split就是最少样本数。\n",
    "           (2).如果为浮点数(0到1之间)，则每个叶子节点最少样本数为ceil(min_samples_leaf * n_samples)\n",
    "6.min_weight_fraction_leaf:float, optional (default=0.)\n",
    "           指定叶子节点中样本的最小权重。\n",
    "7.max_features:int, float, string or None, optional (default=None).\n",
    "           搜寻最佳划分的时候考虑的特征数量。\n",
    "           (1).如果为整数，每次分裂只考虑max_features个特征。\n",
    "           (2).如果为浮点数(0到1之间)，每次切分只考虑int(max_features * n_features)个特征。\n",
    "           (3).如果为'auto'或者'sqrt',则每次切分只考虑sqrt(n_features)个特征\n",
    "           (4).如果为'log2',则每次切分只考虑log2(n_features)个特征。\n",
    "           (5).如果为None,则每次切分考虑n_features个特征。\n",
    "           (6).如果已经考虑了max_features个特征，但还是没有找到一个有效的切分，那么还会继续寻找\n",
    "           下一个特征，直到找到一个有效的切分为止。\n",
    "8.random_state:int, RandomState instance or None, optional (default=None)\n",
    "           (1).如果为整数，则它指定了随机数生成器的种子。\n",
    "           (2).如果为RandomState实例，则指定了随机数生成器。\n",
    "           (3).如果为None，则使用默认的随机数生成器。\n",
    "9.max_leaf_nodes: int or None, optional (default=None)。指定了叶子节点的最大数量。\n",
    "           (1).如果为None,叶子节点数量不限。\n",
    "           (2).如果为整数，则max_depth被忽略。\n",
    "10.min_impurity_decrease:float, optional (default=0.)\n",
    "         如果节点的分裂导致不纯度的减少(分裂后样本比分裂前更加纯净)大于或等于min_impurity_decrease，则分裂该节点。\n",
    "         加权不纯度的减少量计算公式为：\n",
    "         min_impurity_decrease=N_t / N * (impurity - N_t_R / N_t * right_impurity\n",
    "                            - N_t_L / N_t * left_impurity)\n",
    "         其中N是样本的总数，N_t是当前节点的样本数，N_t_L是分裂后左子节点的样本数，\n",
    "         N_t_R是分裂后右子节点的样本数。impurity指当前节点的基尼指数，right_impurity指\n",
    "         分裂后右子节点的基尼指数。left_impurity指分裂后左子节点的基尼指数。\n",
    "11.min_impurity_split:float\n",
    "         树生长过程中早停止的阈值。如果当前节点的不纯度高于阈值，节点将分裂，否则它是叶子节点。\n",
    "         这个参数已经被弃用。用min_impurity_decrease代替了min_impurity_split。\n",
    "12.class_weight:dict, list of dicts, \"balanced\" or None, default=None\n",
    "         类别权重的形式为{class_label: weight}\n",
    "         (1).如果没有给出每个类别的权重，则每个类别的权重都为1。\n",
    "         (2).如果class_weight='balanced'，则分类的权重与样本中每个类别出现的频率成反比。\n",
    "         计算公式为：n_samples / (n_classes * np.bincount(y))\n",
    "         (3).如果sample_weight提供了样本权重(由fit方法提供)，则这些权重都会乘以sample_weight。\n",
    "13.presort:bool, optional (default=False)\n",
    "        指定是否需要提前排序数据从而加速训练中寻找最优切分的过程。设置为True时，对于大数据集\n",
    "        会减慢总体的训练过程；但是对于一个小数据集或者设定了最大深度的情况下，会加速训练过程。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 决策树调参"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 导入库\n",
    "from sklearn.tree import DecisionTreeClassifier\n",
    "from sklearn import datasets\n",
    "from sklearn.model_selection import train_test_split\n",
    "import matplotlib.pyplot as plt\n",
    "from sklearn.model_selection import GridSearchCV\n",
    "from sklearn.tree import DecisionTreeRegressor\n",
    "from sklearn import metrics"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(150, 4) (150,)\n"
     ]
    }
   ],
   "source": [
    "# 导入数据集\n",
    "X = datasets.load_iris()  # 以全部字典形式返回,有data,target,target_names三个键\n",
    "data = X.data\n",
    "target = X.target\n",
    "name = X.target_names\n",
    "x, y = datasets.load_iris(return_X_y=True)  # 能一次性取前2个\n",
    "print(x.shape, y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 数据分为训练集和测试集\n",
    "x_train, x_test, y_train, y_test = train_test_split(x,\n",
    "                                                    y,\n",
    "                                                    test_size=0.2,\n",
    "                                                    random_state=100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最优分类器: {'criterion': 'gini', 'max_depth': 60, 'min_impurity_decrease': 0.2, 'min_samples_leaf': 5} 最优分数: 0.9416666666666665\n"
     ]
    }
   ],
   "source": [
    "# 用GridSearchCV寻找最优参数（字典）\n",
    "param = {\n",
    "    'criterion': ['gini'],\n",
    "    'max_depth': [30, 50, 60, 100],\n",
    "    'min_samples_leaf': [2, 3, 5, 10],\n",
    "    'min_impurity_decrease': [0.1, 0.2, 0.5]\n",
    "}\n",
    "grid = GridSearchCV(DecisionTreeClassifier(), param_grid=param, cv=6)\n",
    "grid.fit(x_train, y_train)\n",
    "print('最优分类器:', grid.best_params_, '最优分数:', grid.best_score_)  # 得到最优的参数和分值"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 参考\n",
    "\n",
    "- https://github.com/fengdu78/lihang-code\n",
    "\n",
    "- 李航. 统计学习方法[M]. 北京: 清华大学出版社,2019.\n",
    "\n",
    "- https://scikit-learn.org"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
